/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "ui插座编辑列表.h"

#include <字符串/str_分割.h>

#include <core/属性.h>
#include <节点/socket_utils.h>
#include <节点/逻辑/执行节点.h>
#include <节点/逻辑/单节点脚本.h>
#include <节点/网格/几何网格.h>
#include <UI/ui绘制模板.h>

#include "A_引擎/引擎.h"
#include "框架/工作区/ui节点面板.h"



static std::vector<S_MapPtrItem> g插座类型;

Inline int32 f_从类型取类型名称字符串(E_值类型 type) {
	int32 选中项 = -1;
	for (auto& e : S_节点数据::g_值类型名称映射) {
		++选中项;
		if (e.second == type) {
			return 选中项;
			break;
		}
	}
	return -1;
}


static std::vector<C_节点基类*> f_get子集输入输出节点(C_节点基类* node, E_插座方向 插座方向) {
	std::vector<C_节点基类*> Nodes;
	switch (node->m_Type) {
	case E_节点类型::e_节点Type_函数: {
		C_函数节点* 多边形节点 = static_cast<C_函数节点*>(node);
		if (插座方向 == E_插座方向::e_插座Type_输入) {
			多边形节点->f_get子集输入节点(Nodes);
		}
		else {
			多边形节点->f_get子集输出节点(Nodes);
		}
		break;
	}
	case E_节点类型::e_节点Type_几何: {
		C_几何节点* 多边形节点 = static_cast<C_几何节点*>(node);
		if (插座方向 == E_插座方向::e_插座Type_输入) {
			多边形节点->f_get子集输入节点(Nodes);
		}
		else {
			多边形节点->f_get子集输出节点(Nodes);
		}
		break;
	}
	case E_节点类型::e_节点Type_循环迭代: {
		C_循环迭代节点* loopNode = static_cast<C_循环迭代节点*>(node);
		if (插座方向 == E_插座方向::e_插座Type_输入) {
			loopNode->f_get子集输入节点(Nodes);
		}
		else {
			loopNode->f_get子集输出节点(Nodes);
		}
		break;
	}
	}

	return Nodes;
}

static void on_画插座编辑列表(C_Widget* self, S_2D画布* 画布) {
	C_插座编辑列表* box = static_cast<C_插座编辑列表*>(self);
	box->m_背景绘制.m_属性 = f_vg_gen属性(画布);

	S_凸边图元 图元 = {};
	图元.属性 = f_vg_get属性指针(画布, box->m_背景绘制.m_属性);
	box->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);

}

static void on_插座编辑列表布局(C_Widget* self, C_Widget** w, uint32 num) {
	float32 h = 24;
	float32 size = 20;
	

	float32 pos = 22;
	//添加按钮
	w[1]->f_setX(self->m_Size.x - pos);
	//删除按钮
	w[2]->f_setPos({ self->m_Size.x - pos, h });
	//上移按钮
	w[3]->f_setPos({ self->m_Size.x - pos, h*2 });
	//下移按钮
	w[4]->f_setPos({ self->m_Size.x - pos, h*3 });

	if (w[5]->m_开启渲染) {
		w[0]->f_setPos({ 2,2 });
		w[0]->f_setSize({ self->m_Size.x - h, self->m_Size.y - (size*3+6) });

		w[5]->f_setPos({ 2, self->m_Size.y - (size * 2 + 2) });
		w[5]->f_setSize({ self->m_Size.x - 4, size });

		w[6]->f_setPos({ 2, self->m_Size.y - size });
		w[6]->f_setSize({ self->m_Size.x - 4, size });
	}
	else {
		w[0]->f_setPos({ 2,2 });
		w[0]->f_setSize({ self->m_Size.x - h, self->m_Size.y - 4});
	}

	
	return;
}

static void on_插座编辑列表属性修改(C_Widget* self) {
	C_插座编辑列表* box = static_cast<C_插座编辑列表*>(self);

	mat3X2 Mat;
	Mat.row0 = {};
	Mat.row1 = box->m_Size;
	Mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };

	box->m_背景绘制.f_alloc(1);
	box->m_背景绘制.f_set单色填充(0, Mat, self->m_颜色A, self->m_图元);
	
}





static void on_插座编辑列表变换修改(C_Widget* self) {
	ui_绘制模板_画预设图形& 背景绘制 = *static_cast<ui_绘制模板_画预设图形*>(self->m_绘图模板[0]);
	ui_绘制模板_图标& 图标绘制 = *static_cast<ui_绘制模板_图标*>(self->m_绘图模板[1]);


	S_2D顶点属性 属性;
	属性.m_比例 = { 1,1 };
	属性.m_偏移 = {};
	属性.m_间隔 = S_UI主题::ui_文字间隔;
	属性.m_渐变数量 = 0;
	f_vg_set属性(self->m_画布, 背景绘制.m_属性, 属性);



	背景绘制.f_alloc(4);

	mat3X2 mat;
	mat.row0 = {};
	mat.row1 = self->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(0, mat, S_UI主题::uic_浅灰, S_Widget预设图元::m_圆角矩形);

	auto e = self->f_get更新部件();
	mat.row0 = e.m_W[0]->m_Pos;
	mat.row1 = e.m_W[0]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(1, mat, e.m_W[0]->m_颜色A, S_Widget预设图元::m_左圆角矩形);

	mat.row0 = e.m_W[2]->m_Pos;
	mat.row1 = e.m_W[2]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(2, mat, e.m_W[2]->m_颜色A, S_Widget预设图元::m_矩形);

	mat.row0 = e.m_W[3]->m_Pos;
	mat.row1 = e.m_W[3]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(3, mat, e.m_W[3]->m_颜色A, S_Widget预设图元::m_右圆角矩形);




	图标绘制.f_alloc(3);
	mat.row0 = e.m_W[0]->m_Pos + e.m_W[0]->m_Size.y * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[0]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set("import", 0, mat, S_UI主题::uic_深白);

	mat.row0 = e.m_W[2]->m_Pos + e.m_W[2]->m_Size.y * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[2]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set("doc_plus", 1, mat, S_UI主题::uic_深白);

	mat.row0 = e.m_W[3]->m_Pos + e.m_W[3]->m_Size.y * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[3]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set("delete", 2, mat, S_UI主题::uic_深白);

	//const auto& 字体 = f_surface_get字体库(*self->m_UIctx, S_UI主题::ui_默认字体);
}





static void on_插座切换类型_项改变(S_Props& prop, S_MapPtr& ptrItem, int32 操作类型) {
	switch (prop.m_Type) {
	case E_值类型::e_Type_PropContainer: 
	case E_值类型::e_Type_LayoutList: {
		break;
	}
	}

	switch (操作类型)
	{
	case E_Prop_MapPtr_项事件类型::e_项删除: {
		ptrItem.m_PtrItem.erase(ptrItem.m_PtrItem.begin() + ptrItem.m_当前项);
		break;
	}

	case E_Prop_MapPtr_项事件类型::e_项添加: {
		S_MapPtrItem item;
		ptrItem.m_PtrItem.push_back(item);
		break;
	}

	case E_Prop_MapPtr_项事件类型::e_项名称改变: {
		break;
	}
	default: {
		uint32 offset = 操作类型;
		S_MapPtrItem& item = ptrItem.m_PtrItem[offset];


		C_插座编辑列表* editlist = static_cast<C_插座编辑列表*>(prop.m_UI->m_部件);
		int32 当前选项 = f_ui_列表框_取当前选中ID(editlist->m_ListBox);
		//if (当前选项 >= f_ui_列表框_取项数量(editlist->m_ListBox)) 当前选项 = 0;

		uint32 插座索引 = 当前选项 + 1;
		//bar->m_View->f_绑定节点树((C_节点树*)item.m_Ptr);
		//++当前选项;
		E_插座方向 插座方向;
		if (editlist->m_Value.m_Name == DEF_输出插座标题) {
			插座方向 = E_插座方向::e_插座Type_输出;
		}
		else {
			插座方向 = E_插座方向::e_插座Type_输入;
		}

		auto& nodes = f_global_get激活节点();
		for (auto& node : nodes) {
			if (插座索引 < node->f_可添加删除插座起始位置(插座方向)) return;

			//E_值类型 插座类型 = S_节点数据::g_值类型名称映射[*item.m_Str];
			E_值类型 插座类型 = S_节点数据::g_值类型名称映射[item.m_Str];

			C_插座基类* socket = f_su_切换后端插座类型(node, 插座方向, 插座索引, 插座类型);

			E_插座方向 颠倒插座方向;
			if (插座方向 == E_插座方向::e_插座Type_输入) {
				for (auto& panel : node->m_包含在多个视口的UI部件) {
					static_cast<C_节点面板*>(panel)->f_getInSocket()[插座索引]->m_SocketData = socket;
				}

				颠倒插座方向 = E_插座方向::e_插座Type_输出;
			}
			else {
				for (auto& panel : node->m_包含在多个视口的UI部件) {
					static_cast<C_节点面板*>(panel)->f_getOutSocket()[插座索引]->m_SocketData = socket;
				}

				颠倒插座方向 = E_插座方向::e_插座Type_输入;
			}
			//socket->on_UI更新(socket);



			C_节点树* tree = node->f_get所在节点树();
			for (auto& t : tree->m_节点树绑定的父节点) {
				auto* newSocket = f_su_切换后端插座类型(t, 颠倒插座方向, 插座索引, 插座类型);

				if (颠倒插座方向 == E_插座方向::e_插座Type_输入) {
					for (auto& e : t->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(e)->f_getInSocket()[插座索引]->m_SocketData = newSocket;
						e->m_绘制属性更新 = true;
					}
				}
				else {
					for (auto& e : t->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(e)->f_getOutSocket()[插座索引]->m_SocketData = newSocket;
						e->m_绘制属性更新 = true;
					}
				}

				//newSocket->on_UI更新(newSocket);
			}

			node->f_更新上层节点(true);


			S_列表填充数据 item;
			if (插座方向 == E_插座方向::e_插座Type_输入) {
				item.m_item.push_back(node->f_get输入插座(插座索引)->m_identifier);
			}
			else {
				item.m_item.push_back(node->f_get输出插座(插座索引)->m_identifier);
			}
			item.m_itemID.push_back(当前选项);
			f_ui_列表框_设置项(editlist->m_ListBox, 当前选项, item);
			break;
		}

		break;
	}
		
	}
	return;
}

static bool on_添加插座(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_插座编辑列表* box = static_cast<C_插座编辑列表*>(self->m_父部件);
	
	int32 添加位置 = f_ui_列表框_取当前选中ID(box->m_ListBox) + 1;
	
	switch (box->m_Value.m_Type) {
	case E_值类型::e_Type_PropContainer: 
	case E_值类型::e_Type_LayoutList: {
		
		E_插座方向 插座方向;
		if (box->m_Value.m_Name == DEF_输出插座标题) {
			插座方向 = E_插座方向::e_插座Type_输出;
		}
		else {
			插座方向 = E_插座方向::e_插座Type_输入;
		}

		auto* socket = f_su_创建节点后端插座(L"value" + f_整数值转宽字符串(添加位置, 2), E_值类型::e_Type_I32);



		if (添加位置 < 0) 添加位置 = 0;

		//++添加位置;
		auto& nodes = f_global_get激活节点();
		for (auto& node : nodes) {
			int32 要添加插座ID;

			要添加插座ID = DEF_Max(node->f_可添加删除插座起始位置(插座方向), 添加位置);
			uint32 添加插座后位置 = 要添加插座ID+1;
			node->f_add插座(socket, 插座方向, 添加插座后位置);

			E_插座方向 跌倒插座方向;
			if (插座方向 == E_插座方向::e_插座Type_输入) {
				for (auto& panel : node->m_包含在多个视口的UI部件) {
					static_cast<C_节点面板*>(panel)->f_addInSocket(socket, 添加插座后位置);
				}

				跌倒插座方向 = E_插座方向::e_插座Type_输出;
			}
			else {
				for (auto& panel : node->m_包含在多个视口的UI部件) {
					static_cast<C_节点面板*>(panel)->f_addOutSocket(socket, 添加插座后位置);
				}

				跌倒插座方向 = E_插座方向::e_插座Type_输入;
			}


			C_节点树* tree = node->f_get所在节点树();
			for (auto& t : tree->m_节点树绑定的父节点) {
				auto* newSocket = f_su_创建节点后端插座(socket->m_identifier, socket->m_Type);
				t->f_add插座(newSocket, 跌倒插座方向, 添加插座后位置);

				if (跌倒插座方向 == E_插座方向::e_插座Type_输入) {
					for (auto& e : t->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(e)->f_addInSocket(newSocket, 添加插座后位置);
					}
				}
				else {
					for (auto& e : t->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(e)->f_addOutSocket(newSocket, 添加插座后位置);
					}
				}
			}


			S_列表填充数据 item;
			item.m_item.push_back(socket->m_identifier);
			item.m_itemID.push_back(-1);
			f_ui_列表框_添加列表项(box->m_ListBox, item, 添加位置);

			break;
		}
		break;
	}

	case E_值类型::e_Type_Object_1D: {
		S_OBArray* obs = (S_OBArray*)f_prop_ArrayContainer(box->m_Value);
		uint32 num = S_节点数据::g_选中激活物体.size();

		for (uint32 i = 0; i < num; ++i) {
			S_物体* ob = S_节点数据::g_选中激活物体[i];
			for (uint32 j = 0; j < obs->count; ++j) {
				if (obs->ptr_userData[j] == ob) {
					ob = nullptr;
					break;
				}
			}

			if (ob) {
				S_列表填充数据 item;
				item.m_itemID.push_back(-1);
				item.m_Data = ob;
				item.m_item.push_back(ob->m_Name);

				f_core_array_push_back((S_Array*)obs, (uint8*)&ob);
				//obs->ptr_userData[index] = ob;
				f_ui_列表框_添加列表项(box->m_ListBox, item, -1);
			}
		}
		break;
	}
	}
	return true;
}

static bool on_移除插座(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_插座编辑列表* box = static_cast<C_插座编辑列表*>(self->m_父部件);

	int32 列表项删除位置 = f_ui_列表框_取当前选中ID(box->m_ListBox);
	if(!f_ui_列表框_取项数量(box->m_ListBox)) return true;
	
	switch (box->m_Value.m_Type) {
	case E_值类型::e_Type_PropContainer: 
	case E_值类型::e_Type_LayoutList: {
		E_插座方向 插座方向;
		if (box->m_Value.m_Name == DEF_输出插座标题) {
			插座方向 = E_插座方向::e_插座Type_输出;
		}
		else {
			插座方向 = E_插座方向::e_插座Type_输入;
		}

		int32 要删除插座 = 列表项删除位置 + 1;
		//++删除位置;
		auto& nodes = f_global_get激活节点();
		for (auto& node : nodes) {
			if (要删除插座 < node->f_可添加删除插座起始位置(插座方向)) 列表项删除位置 = node->f_可添加删除插座起始位置(插座方向) - 1;
			要删除插座 = DEF_Max(node->f_可添加删除插座起始位置(插座方向), 要删除插座);
			

			node->f_del插座(要删除插座, 插座方向);

			E_插座方向 跌倒插座方向;
			if (插座方向 == E_插座方向::e_插座Type_输入) {
				for (auto& panel : node->m_包含在多个视口的UI部件) {
					static_cast<C_节点面板*>(panel)->f_removeInSocket(要删除插座);
				}

				跌倒插座方向 = E_插座方向::e_插座Type_输出;
			}
			else {
				for (auto& panel : node->m_包含在多个视口的UI部件) {
					static_cast<C_节点面板*>(panel)->f_removeOutSocket(要删除插座);
				}

				跌倒插座方向 = E_插座方向::e_插座Type_输入;
			}


			C_节点树* tree = node->f_get所在节点树();
			for (auto& t : tree->m_节点树绑定的父节点) {
				if (跌倒插座方向 == E_插座方向::e_插座Type_输入) {
					if (要删除插座 >= t->f_get输入插座Num()) continue;
				}
				else {
					if (要删除插座 >= t->f_get输出插座Num()) continue;
				}

				for (auto& 同级或其他视口节点面板组件 : t->m_包含在多个视口的UI部件) {
					if (跌倒插座方向 == E_插座方向::e_插座Type_输入) {
						static_cast<C_节点面板*>(同级或其他视口节点面板组件)->f_removeInSocket(要删除插座);
					}
					else {
						static_cast<C_节点面板*>(同级或其他视口节点面板组件)->f_removeOutSocket(要删除插座);
					}
				}

				t->f_del插座(要删除插座, 跌倒插座方向);
			}
		}
		break;
	}
	case E_值类型::e_Type_Object_1D: {
		S_OBArray* obs = (S_OBArray*)f_prop_ArrayContainer(box->m_Value);
		f_core_array_erase((S_Array*)obs, 列表项删除位置);
		break;
	}
	}

	int32 itemNum = f_ui_列表框_移除列表项(box->m_ListBox, 列表项删除位置);
	return true;
}


static bool on_插座类型列表项选中回调(C_Widget* self, const std::vector<std::wstring>& name) {
	C_插座编辑列表* box = static_cast<C_插座编辑列表*>(self->m_父部件);
	if (box) {
		S_列表填充数据 item = f_ui_列表框_取当前选中项(box->m_ListBox);
		if (item.m_item.size()) {
			f_ui_set行文本框文本(box->mui_插座名称编辑框, name[0]);


			auto 选中项 = f_ui_列表框_取当前选中ID(box->m_ListBox) + 1;
			auto& nodes = f_global_get激活节点();
			for (auto& node : nodes) {
				if (box->m_Value.m_Name == DEF_输入插座标题) {
					选中项 = f_从类型取类型名称字符串(node->f_get输入插座(选中项)->m_Type);

				}
				else {
					选中项 = f_从类型取类型名称字符串(node->f_get输出插座(选中项)->m_Type);
				}
				break;
			}
			f_ui_设置下拉列表项(box->mui_插座类型切换下拉列表, 选中项);
		}
	}
	return true;
}

static void on_插座名称编辑改变(C_Widget* self) {
	C_插座编辑列表* box = static_cast<C_插座编辑列表*>(self->m_父部件);
	int32 id = f_ui_列表框_取当前选中ID(box->m_ListBox);
	
	if (id >= 0) {
		auto& nodes = f_global_get激活节点();
		std::wstring name = f_ui_取行编辑框文本(self);
		f_str_去除空白字符(name);

		for (auto& node : nodes) {
			S_列表填充数据 item;

			item.m_item.push_back(name);
			f_ui_列表框_设置项(box->m_ListBox, id, item);

			E_插座方向 插座方向;
			if (box->m_Value.m_Name == DEF_输入插座标题) {
				node->f_get输入插座(id+1)->m_identifier = name;
				插座方向 = E_插座方向::e_插座Type_输出;
			}
			else {
				node->f_get输出插座(id+1)->m_identifier = name;
				插座方向 = E_插座方向::e_插座Type_输入;
			}

			C_节点树* tree = node->f_get所在节点树();
			for (auto& 绑定的父节点 : tree->m_节点树绑定的父节点) {
				if (插座方向 == E_插座方向::e_插座Type_输入) {
					绑定的父节点->f_get输入插座(id+1)->m_identifier = name;
					for (auto& e : 绑定的父节点->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(e)->m_NodeData->f_get输入插座(id+1)->m_identifier = name;
					}
				}
				else {
					绑定的父节点->f_get输出插座(id+1)->m_identifier = name;
					for (auto& e : 绑定的父节点->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(e)->m_NodeData->f_get输出插座(id+1)->m_identifier = name;
					}
				}
			}

			node->f_更新上层节点(true);
		}
		box->m_ListBox->m_绘制属性更新 = true;
	}
}


C_插座编辑列表::C_插座编辑列表(S_UI创建环境& ctx) : C_Widget(&ctx) {
	if (g插座类型.size() < 1) {
		for (auto& e : S_节点数据::g_值类型名称映射) {
			g插座类型.push_back({ nullptr, (e.first), "" });
		}
	}


	mf_DrawFun = on_画插座编辑列表;
	mf_变换修改 = on_插座编辑列表属性修改;
	mf_布局Fun = on_插座编辑列表布局;

	m_ListBox = f_ui_创建列表(E_列表显示模式::e_列表模式_垂直, ctx);
	f_ui_列表框_绑定项选中回调(m_ListBox, on_插座类型列表项选中回调);
	auto addButton = f_ui_创建按钮(&ctx, nullptr);
	auto remButton = f_ui_创建按钮(&ctx, nullptr);
	auto upButton = f_ui_创建按钮(&ctx, nullptr);
	auto downButton = f_ui_创建按钮(&ctx, nullptr);
	addButton->mf_鼠标按键点击 = on_添加插座;
	remButton->mf_鼠标按键点击 = on_移除插座;
	addButton->m_ICO = "加";
	remButton->m_ICO = "减";
	upButton->m_ICO = "上";
	downButton->m_ICO = "下";
	

	mui_插座类型切换下拉列表 = f_ui_创建下拉列表(ctx, false);
	mui_插座类型切换下拉列表->mf_变换修改 = on_插座编辑列表变换修改;

	m_Prop_插座类型切换_下拉列表 = f_alloc_StrIndexProp(g插座类型, L"插座类型");
	m_Prop_插座类型切换_下拉列表.m_UI->m_部件 = this;
	auto& p = f_prop_MapPrt(m_Prop_插座类型切换_下拉列表);
	p.mf_元素变更 = on_插座切换类型_项改变;
	f_ui_绑定下拉列表属性(mui_插座类型切换下拉列表, m_Prop_插座类型切换_下拉列表);
	//m_Prop_插座类型切换_下拉列表.m_UI->m_Update = on_插座名称编辑改变;

	
	mui_插座名称编辑框 = f_ui_创建行文本编辑框(ctx);
	f_ui_bind编辑框完成回调(mui_插座名称编辑框, on_插座名称编辑改变);

	f_添加子组件(m_ListBox);
	f_添加子组件(addButton);
	f_添加子组件(remButton);
	f_添加子组件(upButton);
	f_添加子组件(downButton);
	f_添加子组件(mui_插座类型切换下拉列表);
	f_添加子组件(mui_插座名称编辑框);

	f_setSize({ 256,512 });

	m_颜色A = S_UI主题::uic_深灰;
	m_图元 = S_Widget预设图元::m_圆角矩形;
}

C_插座编辑列表::~C_插座编辑列表() {
	f_prop_Release(m_Prop_插座类型切换_下拉列表);
	C_Widget::~C_Widget();
}


C_插座编辑列表* f_创建插座编辑列表(S_UI创建环境& ctx) {
	C_插座编辑列表* box = new C_插座编辑列表(ctx);
	return box;
}

void f_插座编辑列表绑定属性数据(C_Widget* self, S_Props& prop) {
	C_插座编辑列表* box = static_cast<C_插座编辑列表*>(self);
	box->m_Value = prop;

	f_ui_列表框_删除项(box->m_ListBox, -1);


	switch (prop.m_Type) {
	case E_值类型::e_Type_PropContainer: 
	case E_值类型::e_Type_LayoutList: {
		bool isInSocket = true;
		if (box->m_Value.m_Name == DEF_输出插座标题) {
			isInSocket = false;
		}
		//auto 选中项 = f_ui_列表框_取当前选中项(box->m_ListBox);
		auto 选中项 = f_ui_列表框_取当前选中ID(box->m_ListBox);
		if(选中项 < 0) 选中项 = 0;

		auto& nodes = f_global_get激活节点();
		for (auto& node : nodes) {
			std::vector<S_列表填充数据> items;
			if (isInSocket) {
				uint32 输入插座Num = node->f_get输入插座Num();
				for (uint32 i = 1; i < 输入插座Num; ++i) {
					auto socket = node->f_get输入插座(i);
					S_列表填充数据 item;
					item.m_item.push_back(socket->m_identifier);
					item.m_itemID.push_back(-1);
					items.push_back(item);
					//f_ui_列表框_添加列表项(box->m_ListBox, item, -1);
				}

				auto* socket = node->f_get输入插座(选中项 + 1);
				选中项 = f_从类型取类型名称字符串(socket->m_Type);
			}
			else {
				uint32 输出插座Num = node->f_get输出插座Num();
				for (uint32 i = 1; i < 输出插座Num; ++i) {
					auto socket = node->f_get输出插座(i);
					S_列表填充数据 item;
					item.m_item.push_back(socket->m_identifier);
					item.m_itemID.push_back(-1);
					items.push_back(item);
					//f_ui_列表框_添加列表项(box->m_ListBox, item, -1);
				}

				auto* socket = node->f_get输出插座(选中项 + 1);
				选中项 = f_从类型取类型名称字符串(socket->m_Type);
			}
			f_ui_列表框_填充(box->m_ListBox, items);
		}

		f_ui_设置下拉列表项(box->mui_插座类型切换下拉列表, 选中项);
		box->mui_插座类型切换下拉列表->m_开启渲染 = true;
		break;
	}

	case E_值类型::e_Type_Object_1D: {
		S_OBArray* obs = (S_OBArray*)f_prop_ArrayContainer(prop);
		for (uint32 i = 0; i < obs->count; ++i) {
			S_列表填充数据 item;
			item.m_item.push_back(obs->ptr_userData[i]->m_Name);
			item.m_itemID.push_back(-1);
			f_ui_列表框_添加列表项(box->m_ListBox, item, -1);
		}

		box->mui_插座类型切换下拉列表->m_开启渲染 = false;
		break;
	}
	default:
		break;
	}


	
}


